/////////////////////////////////////////////////////////////////////////
// 解释器

use std::cell::RefCell;
use super::nast::FunctionBody;
use super::nast::FunctionCall;
use super::nast::IAstVisitor;
use super::nast::AstNodes;
use super::nast::Prog;
use super::nast::Statements;

/**
 * 遍历AST，执行函数调用。
 */
pub struct Intepretor  {
}

impl IAstVisitor for Intepretor{
	fn visit_prog(&self, prog: &mut Prog) -> Option<AstNodes> {
		let mut ret_val:Option<AstNodes> = None;
		let x = (*prog).clone();

		//执行所有的函数调用
		for stmt in x.stmts {
			//根据stmt的类型，进行不同的处理
			ret_val = match stmt {
				Statements::FunctionDecl(_v) => {None},
				Statements::FunctionCall(v) => self.run_function(prog, &v),
			  };
		}
		return ret_val;
	}
}

impl Intepretor{
	pub fn new() -> Intepretor {
		Intepretor{}
	}

	//执行一个函数体
	pub fn visit_function_body(&self, prog: &Prog, function_body :Option<RefCell<FunctionBody>>) ->Option<AstNodes> {
        if function_body.is_none(){
			return None;
		}

		let mut ret_val:Option<AstNodes> = None;

		let x = function_body.unwrap();
		//依次执行每条函数调用
		for stmt in &x.borrow().stmts {
			ret_val = self.run_function(prog, stmt);
		}

		return ret_val;
	}

	//执行一个函数
	pub fn run_function(&self, prog: &Prog, function_call :&FunctionCall) -> Option<AstNodes> {
		let fc : FunctionCall = function_call.clone();

		if fc.name.starts_with("nl.") {
			//内置函数
			if fc.name.eq("nl.println") {
				if fc.parameters.len() > 0 {
					println!("{}",fc.parameters[0]);
				} else {
					println!();
				}
				return None
			}
		} else {
			//自定义函数
			//找到函数定义，继续遍历函数体
			if fc.definition_index>=0{
				let stmt = &prog.stmts[fc.definition_index as usize];
				match stmt {
					Statements::FunctionDecl(v) => {
						self.visit_function_body(prog, v.clone().body);
					},
					Statements::FunctionCall(_v) => {
					},
				  };
				
			} else{
				println!("{},{}", fc.name , " not found1!!");
			}
		}
		return None
	}
}